const express = require('express');
const router = express.Router();
const jwt = require('jsonwebtoken');
const db = require('../config/database');
const dayjs = require('dayjs')
const bcrypt = require('bcrypt'); //  加密数字的模块
const { authMiddleware, adminMiddleware } = require('./auth');
// 中间件：验证JWT token
const verifyToken = (req, res, next) => {
    const token = req.header('Authorization')?.replace('Bearer ', '');
    if (!token) {
        return res.status(401).json({ msg: '未提供访问令牌' });
    }

    try {
        const decoded = jwt.verify(token, process.env.JWT_SECRET);
        req.user = decoded;
        next();
    } catch (error) {
        res.status(401).json({ msg: '无效的访问令牌' });
    }
};

// 密码强度验证规则
const PASSWORD_REGEX = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}/;

// 获取用户列表
router.get('/', verifyToken, async (req, res) => {
    try {
        const [users] = await db.pool.query(
            'SELECT id, username, email, role, created_at FROM users'
        );
        // res.json(response(0, '成功', users));
        res.json({
            code: 0,
            msg: '成功',
            data: users
        });
    } catch (error) {
        console.error('获取用户列表失败:', error);
        // res.status(500).json(response(-1, '服务器错误'));
        res.status(500).json({
            code: -1,
            msg: '服务器错误'
        });
    }
});

// 获取单个用户信息
router.get('/:id', verifyToken, async (req, res) => {
    try {
        const [users] = await db.pool.query(
            'SELECT id, username, email, role, created_at FROM users WHERE id = ?',
            [req.params.id]
        );

        if (users.length === 0) {
            return res.status(404).json({ code: -1, msg: '用户不存在', data: {} });
        }

        // res.json(response(0, '成功', users[0]));
        res.json({
            code: 0,
            msg: "请求成功",
            data: users
        })
    } catch (error) {
        console.error('获取用户信息失败:', error);
        // res.status(500).json(response(-1, '服务器错误'));
        res.status(500).json({
            code: -1,
            msg: "服务器错误",
        })
    }
});

// 创建新用户---应该用注册接口代替
router.post('/', [authMiddleware, verifyToken], async (req, res) => {
    const { username, email, password, role, age = 18, major = null, phone } = req.body;
    // 验证必填字段
    if (!username || !email || !password || !role || !phone) {
        return res.status(400).json({ code: -1, msg: '用户名、邮箱、角色、手机号和密码不能为空', data: {} });
    }

    // 验证用户名格式（2-50个字符，允许中文、字母、数字和下划线）
    if (!/^[\u4e00-\u9fa5a-zA-Z0-9_]{2,50}$/.test(username)) {
        return res.status(400).json({ code: -1, msg: '用户名格式不正确（2-50个字符，允许中文、字母、数字和下划线）', data: {} });
    }

    // 验证邮箱格式
    if (!/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(email)) {
        return res.status(400).json({ code: -1, msg: '邮箱格式不正确', data: {} });
    }

    // 验证手机号
    if (!/^1[3-9]\d{9}$/.test(phone)) {
        return res.status(400).json({ code: -1, msg: '手机号不正确', data: {} });
    }

    // 验证密码强度
    if (!PASSWORD_REGEX.test(password)) {
        return res.status(400).json({ code: -1, msg: '密码必须包含大小写字母和数字，且长度至少8位', data: {} });
    }
    const newTime = dayjs(new Date()).format("YYYY-MM-DD HH:mm:ss")
    try {
        // 检查用户名是否已存在
        const [existingUsers] = await db.pool.query(
            'SELECT id FROM users WHERE username = ? OR email = ?',
            [username, email]
        );

        if (existingUsers.length > 0) {
            return res.status(400).json({ msg: '用户名或邮箱已存在' });
        }

        const hashedPassword = await bcrypt.hash(password, 10);
        // 创建新用户
        const [result] = await db.pool.query(
            'INSERT INTO users (username, email, password, role, created_at, age, major, phone) VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
            [username, email, hashedPassword, role || 'user', newTime, age, major, phone]
        );

        // 获取新创建用户的ID
        const newUserId = result.insertId;

        // 记录操作日志
        await db.pool.execute(
            'INSERT INTO system_logs (user_id, action, description) VALUES (?, ?, ?)',
            [req.user.id, 'user_create', `新建用户:username:${username},ID ${newUserId}`]  // 使用实际的newUserId
        );

        res.json({
            code: 0, msg: '创建用户成功', data: {
                id: result.insertId,
                username,
                email,
                role: role || 'user'
            }
        });
    } catch (error) {
        console.error('创建用户失败:', error);
        // res.status(500).json(response(-1, '服务器错误'));
        res.status(500).json({
            code: -1,
            msg: "服务器错误"
        })
    }
});

// 更新用户信息
router.put('/:id', verifyToken, async (req, res) => {
    const { username, email, password, role } = req.body;
    const userId = Number(req.params.id);
    // 验证密码强度
    if (!PASSWORD_REGEX.test(password)) {
        return res.status(400).json({ code: -1, msg: '密码必须包含大小写字母和数字，且长度至少8位', data: {} });
    }
    try {
        // 检查用户是否存在
        const [existingUser] = await db.pool.query(
            'SELECT id FROM users WHERE id = ?',
            [userId]
        );

        if (existingUser.length === 0) {
            return res.status(404).json({ code: -1, msg: '用户不存在', data: {} });
        }

        const hashedPassword = await bcrypt.hash(password, 10);
        // 构建更新查询
        const updates = [];
        const values = [];
        if (username) {
            updates.push('username = ?');
            values.push(username);
        }
        if (email) {
            updates.push('email = ?');
            values.push(email);
        }
        if (password) {
            updates.push('password = ?');
            values.push(hashedPassword);
        }
        if (role) {
            updates.push('role = ?');
            values.push(role);
        }

        if (updates.length === 0) {
            return res.status(400).json({ msg: '没有提供要更新的信息' });
        }

        values.push(userId);
        const [result] = await db.pool.query(
            `UPDATE users SET ${updates.join(', ')} WHERE id = ?`,
            values
        );

        res.json({ code: 0, msg: '用户信息更新成功', data: result });
    } catch (error) {
        console.error('更新用户信息失败:', error);
        // res.status(500).json(response(-1, '服务器错误'));
        res.status(500).json({
            code: -1,
            msg: "服务器错误"
        })
    }
});

// 删除用户
router.delete('/:id', verifyToken, async (req, res) => {
    try {
        const [result] = await db.pool.query(
            'DELETE FROM users WHERE id = ?',
            [req.params.id]
        );

        if (result.affectedRows === 0) {
            return res.status(404).json({ code: -1, msg: '用户不存在', data: {} });
        }

        res.json({ code: 0, msg: '用户删除成功' });
    } catch (error) {
        console.error('删除用户失败:', error);
        // res.status(500).json(response(-1, '服务器错误'));
        res.status(500).json({
            code: -1,
            msg: "服务器错误"
        })
    }
});

module.exports = router;